Multi-objective and multi constrained task scheduling framework for computational grids

Grid computing emerged as a powerful computing domain for running large-scale parallel applications. Scheduling computationally intensive parallel applications such as scientific, commercial etc., computational grids is a NP-complete problem. Many researchers have proposed several task scheduling algorithms on grids based on formulating and solving it as an optimization problem with different objective functions such as makespan, cost, energy etc. Further to address the requirements/demands/needs of the users (lesser cost, lower latency etc.) and grid service providers (high utilization and high profitability), a task scheduler needs to be designed based on solving a multi-objective optimization problem due to several trade-offs among the objective functions. In this direction, we propose an efficient multi-objective task scheduling framework to schedule computationally intensive tasks on heterogeneous grid networks. This framework minimizes turnaround time, communication, and execution costs while maximizing grid utilization. We evaluated the performance of our proposed algorithm through experiments conducted on standard, random, and scientific task graphs using the GridSim simulator.

address these limitations by simultaneously optimizing multiple objectives, offering more robustness for users to prioritize one or more criteria over other and diverse solutions.
Multi-objective function optimization involves optimizing multiple conflicting objectives simultaneously.Common heuristic approaches for multi-objective task scheduling include the application of genetic algorithms (NSGA, NSGA-II) 17,18 , particle swarm optimization (MOPSO) 19 , simulated annealing(MOSA) 20 , ant colony optimization (MOACO) 21 , and other evolutionary (MOEAs) 22 etc.These methods leverage principles inspired by natural processes to explore the solution space and find trade-off solutions among conflicting objectives.In our proposed method, heuristics are utilized as general problem-solving strategies, employing intuitive, trialand-error methods to quickly find effective solutions.This systematic approach is designed to identify the best solution based on a defined objective function or set of criteria.Heuristics serve as rule-of-thumb methods, particularly valuable when an exhaustive search or an exact solution is impractical.The objective of incorporating heuristic approaches into our framework is to strike a balance among competing objectives.This includes minimizing turnaround time, execution cost, and communication cost while maximizing resource utilization.The application of heuristics enables the derivation of practical and computationally efficient solutions, especially in scenarios where finding an optimal solution proves challenging or unfeasible.In this article, we propose a task scheduling algorithm based on multi-objective optimization formulation with different objective functions such as minimising turnaround time (TAT), task execution cost, data communication cost between resources, and maximising grid utilization in a heterogeneous multi-grid environment.The proposed framework is plugged into a gridsim architecture as shown in Fig. 1(green colour).The framework contains five different schedulers namely 1. Greedy scheduler: prioritizes minimizing turnaround time, communication cost, and execution cost while maximizing grid utilization.2. Greedy communication cost scheduler: minimizes communication cost by distributing tasks across computing resources within a single Grid.3. Greedy execution cost scheduler: aims to minimize execution cost by scheduling each task on the most suitable subset of computing resources based on their cost-to-performance ratio.4. Greedy no fragmentation scheduler: task as fragmented and schedule tasks on individual computing resources.5. Random scheduler: schedules tasks on a random subset of computing resources.www.nature.com/scientificreports/ to solve multi-objective problems.Thus, TOPSIS is a valuable decision-making technique because it provides a systematic and structured approach to evaluate and rank alternatives based on multiple criteria, helping end users to make well-justified choices in complex decision scenarios.

Task model
The task scheduling framework consists of a task graph, a task scheduler and a grid network.A task graph is an input to a task scheduler and is defined as a Weighted Directed Acyclic Graph (WDAG) WTG = (T, E) .where T is set of tasks and E set of edges which describes the dependency between tasks.The weight W(T i ) is assigned to task T i represents the size of a i th task and is expressed as Million Instructions (MI).

Grid model
Grid network consists of set of grid nodes G = {G 1 , G 2 , G 3 , ..., G m } and they are interconnected by high speed network.Each grid node contains p number of heterogeneous processing elements G i = {r i1 , r i2 , r i3 , ..., r ip } and these processing elements are internally connected by a high-speed communication network.Processing speed / CPU_speed of each processor is represented in terms of Million Instructions Per Second (MIPS).Each computational grid contains a local scheduler, The function of the local scheduler is to manage the execution of a task on a grid resource given by the task scheduler.The local scheduler is also responsible for collecting information about computational resources periodically and communicating with the task scheduler.

Simulation model
GridSim 66 We have employed a Java-based discrete-event toolkit called GridSim to simulate our multi-objective task scheduling framework.This versatile toolkit offers a comprehensive suite of features for modelling and simulating resources and network connectivity, accommodating various capabilities and configurations.Among its capabilities are primitives for composing applications, information services for resource discovery, and interfaces for task allocation to resources and managing their execution.These capabilities enable us to simulate resource brokers or grid schedulers, facilitating the evaluation of scheduling algorithms' performance.It's worth noting that GridSim does not prescribe any specific application model, but in our proposed framework, we have adopted a Directed Acyclic Graph (DAG) as the application model.Within the GridSim environment, individual tasks can exhibit differing processing times and input file sizes.To represent these tasks and their requirements, we utilize Gridlet objects.Each Gridlet encapsulates comprehensive information related to a job, including execution management details such as job length (measured in MIPS), disk I/O operations, input and output file sizes, and the job's originator.In the context of GridSim, a Processing Element (PE) stands as the smallest computing unit, configurable with varying capacities denoted in Million Instructions per Second (MIPS).Multiple PEs can be combined to construct a machine, and in a similar fashion, machines can be aggregated to form a grid.Grids can allocate Gridlets in either a time-sharing mode (common in single-processor Grids) or a space-sharing mode (typical for multi-processor Grids).

Existing GridSim architecture
Proposed multi-layer architecture and abstractions are shown in Fig. 1.The layered structure of this system begins with the foundational run-time machinery, known as the JVM (Java Virtual Machine).This JVM is versatile, catering to both single and multiprocessor systems, including clusters.Moving up to the second layer, we encounter a fundamental discrete-event infrastructure that relies on the interfaces offered by the first layer.This infrastructure is actualized through SimJava, a well-regarded Java library for discrete event simulation.
The third layer delves into the simulation of essential grid entities, encompassing resources and information services, among others.Here, the GridSim toolkit employs the discrete event services provided by the underlying infrastructure to simulate these core resource entities.Ascending to the fourth layer, our attention turns to the simulation of resource aggregators, often referred to as grid resource brokers or schedulers.Finally, the fifth and topmost layer is dedicated to application and resource modelling across various scenarios.It harnesses the services furnished by the two lower-level layers to evaluate scheduling strategies, resource management policies, heuristics, and algorithms.

Life cycle of a GridSim simulation
Prior to commencing a simulation, we establish the resource entities (including PEs, Machines, and Grids) that will be available throughout the simulation.Upon GridSim's initiation, these resource entities autonomously enroll themselves with the Grid Information Service (GIS) entity by dispatching relevant events.Furthermore, at the onset of the simulation, a user initiates the process by submitting their job to a Resource Broker.The resource broker plays a pivotal role in the simulation, encompassing several responsibilities.It first employs information services to identify accessible resources for the user.Subsequently, it performs task-toresource mapping (scheduling), orchestrates the staging of application components and data for processing (deployment), initiates job execution, and ultimately aggregates the results.Beyond these tasks, the resource broker also takes on the crucial role of monitoring and tracking the progress of application execution.

Our resource broker implementation
All the application models we have explored rely on task inter-dependencies, which are precisely defined using Directed Acyclic Graphs (DAGs).Regrettably, GridSim does not inherently accommodate the execution of www.nature.com/scientificreports/tasks that are constrained by these inter-dependencies.In response to this limitation, our Resource Broker implementation extends support for such scenarios by ensuring that the order of task execution adheres to the specified dependency constraints.Our Resource Broker defines a versatile task Scheduler interface, offering seamless integration with various schedulers.This interface serves as a plug-and-play mechanism, enabling the utilization of multiple schedulers introduced in our work (GS, GCPS, GEPS, GNFS), all of which adhere to this common interface.Furthermore, our task scheduling framework introduces an innovative concept called task fragmentation, allowing tasks to be divided for execution across multiple computing resources.To facilitate this, our resource broker incorporates a Gridlet Fragmentation Service.When a gridlet is scheduled to run on more than one Processing Element, it is initially fragmented into multiple smaller virtual gridlets.These virtual gridlets are then individually executed by the allocated Processing Elements.Upon their completion, the Gridlet Fragmentation Service reunites them into the original single gridlet.Another novel concept introduced by our task scheduling framework involves partial dependencies among tasks.However, GridSim does not inherently enable the Resource Broker to monitor task progress during execution.To address this, we have implemented a pinger service within the Resource Broker and individual Processing Elements.This pinger service allows the Broker to stay informed about a gridlet's execution progress, enabling it to schedule child tasks once a parent task has reached a predefined threshold percentage of execution, as dictated by the parent-child dependency.Lastly, we have enhanced the Resource Broker with the capability to gather performance statistics, including Turnaround Time, Resource Utilization, Execution Price, and Communication Price.These statistics provide valuable insights into the system's performance.

Formulation of multi-objective optimization for task scheduling
We propose task scheduling problem as a multi-objective optimization problem with a goal to minimize TAT, execution price, communication price and maximize grid utilization for precedence constrained task graphs is represented as argmin(TAT , EP,CP, −GU).
The objective function for TAT is defined and formulated as shown in Eq. ( 1).
where X ij k = 1, if the taskT i is scheduled on the jth grid on its kth resource 0, otherwise.τ ij k = Execution time of Task T i on k'th resource of grid j Grid Utilization is formulated in Eq. (2).
Task execution price and communication price is defined and formulated in Eqs.(3) and (4) respectively.Rest of the paper used price and cost interchangeably. Where 1, if the task T i is scheduled on on any machine of GridG j 0, otherwise.

Proposed task scheduling algorithm
Proposed Multi-Objective task scheduling algorithm is described in algorithm 2. Algorithm generates an optimized schedule sequence (task-id, [grid-ID, machine-ID], execution start-time and end-time) according to multiple objectives (TAT, EC, CC and RU).
Input to the algorithm is number of tasks(n), task dependency graph (weighted adjacency matrix WTG [1, ..., n][1, ..., n]), task lengths ( W T [1, ..., n] ), number of grids(m), number of machines p [1, ..., m] in each grid, processing capacity of each grid in terms of MIPS ( W G [1, ..., m]) , and the user's objective optimization criteria (See 2 for choices).The algorithm's output is the optimized task schedule sequence (step 1 and 2).Step 3 generates all possible combinatorial subsets of Grid-Machines that a task can be allocated onto, depending on the user's objective optimization criteria, as so: If the user criteria is GS then this step generates all possible subsets of grid-machines sets.If the user criteria is GCPS then it generates combinatorial sets of grid machines with all the machines in each set belonging to the same grid.If the user criteria is GEPS then it generates combinatorial sets of grid-machines which offer the lowest task execution price (other Grid-Machines are ignored).Similarly, if the user criteria is GNFS then it generates singleton sets of all the individual grid-machines.The algorithm then executes in a loop (from Step 7) until all the tasks have been scheduled.On every iteration of the loop, the algorithm first identifies (in Step 8) tasks whose parent task dependency constraints have been met and are thus available for scheduling.Step 4 then uses function (5) to select the best task and Grid-Machine combination for scheduling.Steps 11 to 13 append this Task-Grid-Machine allocation to the schedule sequence, and update the information about available Grid Machines and unscheduled tasks.Finally, Steps 14, 15 enter into a blocking wait until one or more Grid-Machines are available, after which, the algorithm enters into another iteration of the Step 7 loop.

Demonstration of the proposed task scheduling algorithm
To enhance comprehension of the proposed algorithm 2, we'll illustrate its functionality through an example, using concise input parameters.This demonstration will cover four distinct user objective types (GS, GEPS, GCPS, GNFS).
Consider an application with workload characterized by a task graph comprising four tasks, each task contains 60 million instructions (MI).This task graph is represented as a Directed Acyclic Graph (DAG), as shown in Fig. 2a.Similarly, a grid network, depicted in Fig. 2b, comprises two grids: G 1 housing Grid-Machine G 1 M 1 and G 2 hosting Grid-Machines G 2 M 1 and G 2 M 2 .Each Grid-Machine possesses a processing capacity of 2 mil- lion instructions per second (MIPS).These specifications in Table 1, serve as the inputs for Algorithm 2. In the following subsections, we illustrate the iterations executed by the proposed scheduling algorithm and the corresponding helper functions for each distinct objectiveType.

Objective type: greedy scheduler
Function f g () (described in Table 2) generates 7 possible combinations of Grid-Machine subsets to allocate tasks for the Greedy Scheduler objectiveType, as illustrated in Table 3.
(5) www.nature.com/scientificreports/Function f s () (described in Eq. ( 5)) computes a preference matrix for scheduling each task on each of the generated Grid-Machine subsets, as shown in Table 4.Then, Algorithm 2 computes the schedule sequence of task allocations onto Grid-Machines, as shown in Table 5.

Objective type: greedy communication price scheduler
Function f g () (described in Table 2) generates 4 possible combination of Grid-Machine subsets to allocate tasks for a Greedy Scheduler objectiveType, as illustrated in Table 6.Function f s () (described in Eq. ( 5)) computes a preference matrix for scheduling each task on each of the generated Grid-Machine subsets, as shown in Table 7.Then, Algorithm 2 computes the schedule sequence of task allocations onto Grid-Machines, as depicted in Table 8.
Table 1.Input parameters to the scheduling algorithm 2.
GS Generate all possible combinatorial subset of grid-machines

GCCS
Generate combinations of grid-machines with all the machines in each subset belonging to the same grid

GECS
Generate combinatorial subsets of all grid-machines that offer the lowest execution price (Ignore other Grid-Machines)

GNFS
Generate singleton subsets of all the grid-machines Table 3. Grid-Machine subsets generated by f g () for objectiveType=G.

Objective type: greedy no fragmentation scheduler
Function f g () (described in Table 2) generates 3 possible combination of Grid-Machine subsets to allocate tasks for the Greedy Scheduler objectiveType, as illustrated in Table 9. Function f s () (described in Eq. ( 5)) computes a preference matrix for scheduling each task on each of the generated Grid-Machine subsets, as shown in Table 10.Then, Algorithm 2 computes the schedule sequence of task allocations onto Grid-Machines, as shown in Table 11.
Table 5. Schedule sequence of tasks allocations to grid-machines by Greedy scheduler for objectiveType=G.

Time (s) Available tasks
freeGMs Complete; TAT = 4s Table 6.Grid-Machine subsets generated by f g () for objectiveType=G CP . GMSubset Complete; TAT = 6s Table 9. Grid-machine subsets generated by f g () for objectiveType=Greedy NF . GMSubset Vol:.( 1234567890) Function f g () (described in Table 2) generates 4 possible combination of Grid-Machine subsets to allocate tasks for the Greedy Scheduler objectiveType, as illustrated in Table 12.Function f s () (described in Eq. ( 5)) computes a preference matrix to schedule a task on each of the generated Grid-Machine subsets, as shown in Table 13.Then, Algorithm 2 computes the schedule sequence of task allocations onto Grid-Machines, as shown in Table 14.

Simulation setup
The proposed multi objective task scheduling framework is simulated using GridSim.Simulation is carried out on three types of task graphs : standard task graphs, random task graphs and scientific task graphs on ubuntu operating system with AMD Ryzen 5 processor.The framework includes five distinct task schedulers, each designed to optimize different target objectives: 1. Greedy scheduler: Prioritizes minimizing turnaround time, communication cost, and execution cost while maximizing grid utilization.2. Greedy Communication Cost scheduler: Focused on minimizing communication cost by distributing tasks across computing resources within a single Grid.3. Greedy Execution Cost scheduler: Aims to minimize execution cost by scheduling each task on the most suitable subset of computing resources based on their cost-to-performance ratio.4. Greedy No Fragmentation scheduler: Aims to schedule tasks on individual computing resources, resulting in zero task fragmentation. 5. Random scheduler: Schedules tasks on a random subset of computing resources.
Table 15 explicates the notations used in the mathematical models and algorithms.Table 16 delineates the symbols representing various scheduling algorithms, while Table 17 furnishes a catalogue of scientific application graphs used in the current study.
Out degree of Task T i on the task dependency graph i.e. the number of child tasks dependent on Task T i

Epigenomics
Created by the USC Epigenome Center and the Pegasus Team to automate various operations in genome sequence processing.

Cybershake
Used by the Southern California Earthquake Center to characterize earthquake hazards in a region.www.nature.com/scientificreports/

Gausian elimination
The proposed task scheduling algorithm is evaluated using standard, random and scientific task graphs.

Standard task graphs
Our earlier research, as presented in 63 , demonstrated theorems for standard unit size task graphs on a homogeneous grid network for turnaround time.Similarly, in 64 , we stated theorems for grid utilization.In this article, we have formulated mathematical models for homogeneous standard-weighted task graphs on a homogeneous grid network for both fragmented and non-fragmented versions of the task graphs.These formulations are defined in Tables 18 and 19 respectively.TAT obtained from the proposed algorithm is tabulated in Table 20.The result describes both theoretical and simulated results for various standard task graphs (with fragmentation and without fragmentation) for a given number of tasks, grids, and processing elements.Here each task contains a uniform number of instructions ( W Ti = 20000 MI) and homogeneous processing elements ( W GR = 500 MIPS) in each grid.Computed TAT is on par with our mathematical formulations.From the results, it is evident that as number of tasks increases, TAT also increases.Similarly, The computed values of turnaround time, execution cost, communication cost, and resource utilization using proposed schedulers for pipeline, star, ternary, independent and fully connected task graphs with varying number of task nodes and a given number of grid resources are tabulated in Tables 21, 22 and 23 respectively.From these results, it has been found that the greedy scheduler successfully optimizes for the fastest turnaround time along with grid utilisation, but the trade-off is that the communication cost is high.However, the greedy communication cost scheduler with a slightly slower TAT successfully incurs the lowest communication cost.In the absence of task fragmentation, a greedy scheduler achieves optimal grid utilization while incurring zero communication costs.Additionally, it's worth noting that the execution cost remains consistent across different task schedulers when standard graphs are processed on a homogeneous grid network.As the nature of the graphs becomes increasingly independent (such as star graphs or independent graphs), most schedulers yield similar turnaround times due to the reduced dependency constraints.The Random scheduler, inherently achieves TAT, Resource Utilization, and Communication cost in between the extremes achieved by the other schedulers.Another interesting observation is that greedy scheduler achieves maximum resource utilization and minimum turnaround time, albeit by incurring the highest communication and execution costs.

Random task graphs
Random task graphs with diverse levels of connectivity (0%, 25%, 50%, 75%, and 100%) is generated by using algorithm-2 64 .The outcomes of our proposed algorithm, encompassing TAT, resource utilization, execution cost, and communication cost, are depicted in Fig. 3 through Fig. 4. From these results, we can conclude that the turnaround time increases due to the increase in the number of tasks and also the increase in task dependency.This is shown in Figs. 5, 6, 7 and 8. Also when tasks are scheduled without fragmentation TAT increases as compared to tasks with fragmentation.
Resource utilization decreases when scheduling a random task graph with a higher degree of dependency without fragmentation (as seen in Figs. 5, 6, 7, and 8), in contrast to when tasks are fragmented.Additionally, it's Table 18.TAT for weighted fragmented standard task graphs.

Task graph TAT
Pipe line Table 19.TAT for weighted non-fragmented standard task graphs.

Task graph TAT
Pipe line noteworthy that all schedulers perform optimization for turnaround time and resource utilization when there is no inter dependency among the tasks, as illustrated in Fig. 3.As the inter dependency between tasks within a task graph increases (with connectivity's of 0% as shown in Fig. 9, 25% connectivity as shown in Fig. 10, 50% in Fig. 11, 75% in Fig. 12, and 100% in Fig. 13), it becomes evident that the greedy scheduler achieves the lowest Turnaround Time (TAT).However, this comes at the cost of higher communication expenses due to the fragmentation of tasks.Conversely, a greedy scheduler without task fragmentation incurs zero communication costs in all cases, effectively eliminating this expense from the scheduling process.

Scientific task graphs
The performance of the proposed algorithm is also evaluated by using scientific graphs such as Montage, Cyber-Shake, LIGO etc.Here all workflows are generated by Pegasus Workflow Generator 65        www.nature.com/scientificreports/Our observation reveals that across all application task graphs, the greedy scheduler consistently generates schedules with the most optimal TAT and resource utilization.However, it's important to note that this optimization is achieved at the expense of incurring the highest communication and execution costs compared to the schedules generated by the other schedulers.www.nature.com/scientificreports/A consistent trend that emerges across all schedulers is the inverse relationship between resource utilization and the extent of parallel execution of tasks, which is dictated by the inter-dependency constraints among tasks.For example, in the case of the Gaussian Elimination and Montage scientific application graphs, where tasks exhibit a high degree of inter-dependency, the scheduling sequences result in the lowest resource utilization.This highlights the influence of task inter-dependency on resource allocation and utilization in the scheduling process.
Similarly, computed values of turnaround time, execution cost, communication cost, and resource utilization using proposed schedulers for different scientific task graphs is tabulated in Table 27.

Formulation of the multi-objective-decision-making problem The generic multi-attribute-decision-making (MADM) problem
Scheduling tasks in a grid network can be conceptualized as a MADM problem.In the context of MADM, the goal is to assess and prioritize various alternative solutions denoted as A i (i = 1, 2, 3, . . ., I) , taking into account specific criteria.These criteria, represented as C j (j = 1, 2, 3, . . ., J) , encapsulate the factors that play a role in influencing the ranking of the alternative solutions within the set A i .
Each alternative solution, denoted as A i , undergoes an evaluation against each individual criterion, repre- sented by C j .This evaluation process produces a performance rating matrix X = (x ij ) (I×J) .
The user is tasked with specifying a set of weights, denoted as W = w j (j = 1, 2, . . ., J) , which serve as indicators of the user's individual preferences for each criterion, C j .www.nature.com/scientificreports/ 4. Collecting a user's preferences for each criterion involves ranking these criteria in descending order of importance.Weights are then allocated using a Geometric Progression, with greater weights being assigned to criteria ranked higher in importance by the user.

Solving the MADM problem
The task scheduling MADM problem is addressed using a well-regarded technique within the MADM field known as TOPSIS.TOPSIS operates on the principle that the optimal solution is the one closest to the positiveideal solution while simultaneously being the farthest from the negative-ideal solution.Alternatives are ranked by computing an overall index based on their proximity to these ideal solutions.
The TOPSIS method comprises a series of steps, as follows: 1. Normalize the performance rating matrix.i.e. y ij =
Calculate the Euclidean distance from the positive and negative ideal solutions.www.nature.com/scientificreports/ Calculate the closeness of each alternative solution to the ideal solution.
Determining the rank order of all alternatives on the basis of their relative closeness to the ideal solutions.The larger the V i is, the better the alternative solution A i is.The best alternative solution is the one with the largest closeness to the ideal solution.

TOPSIS results and discussion
To rank the task schedule sequences produced by various schedulers, the TOPSIS method is employed.This method optimizes the selection of schedules according to the user's prioritized objectives, which include Turnaround Time, Resource Utilization, Communication Price, and Execution Price, in terms of their desirability.Tables 28, 29, and 30 presents the result of the TOPSIS algorithm when applied to standard, random, and scientific task graphs, respectively.We explore different possible priority orders that users may assign to each criterion.Notably, we find a consistent ranking pattern for schedule sequences across all types of graphs, including Standard, Random, and Scientific graphs, which encompass Fully Connected, Pipeline, Star, Ternary, and Independent graph categories.Additionally, this ranking consistency persists even when the number of tasks varies (40, 121, 364, and 1039).Weightage types 1, 2, 3, 4, as well as 7, 8, 9, and 10, exemplify situations where the user places the highest importance on turnaround time and resource utilization as criteria, while assigning less significance to communication cost and execution cost.In these scenarios, TOPSIS consistently ranks the greedy scheduler as the top solution.The second-best alternative solution is the greedy communication cost scheduler, which outperforms the other schedulers in terms of TAT and resource utilization.
However, in cases corresponding to weightage types 5, 6, 10, and 11, where the user's preference primarily focuses on achieving an optimal communication cost, TOPSIS identifies the schedule generated by the greedy communication scheduler as the best solution.This scheduler minimizes communication costs to zero while maintaining TAT and resource utilization levels that are nearly on par with those achieved by the greedy scheduler.In this context, the output schedule sequence of the greedy scheduler is ranked last by TOPSIS, as it incurs the highest communication cost, contradicting the user's prioritization of criteria desirability.

Conclusion and future work
In this paper, we presented a multi-objective task scheduling framework for scheduling different types of workflows on computational grids.The main objective of our proposed framework is to minimize the overall execution cost, including application turnaround time and communication cost, while maximizing grid utilization.The proposed scheduling framework is integrated with GridSim and validated through experiments conducted on weighted standard task graphs, weighted random task graphs, and scientific task graphs.Furthermore, we envisaged a multi-criteria decision method called Technique for Order of Preference by Similarity to Ideal

Algorithm 1 .Algorithm 2 .Algorithm 3 .
Multi-objective task scheduler.Generic single-objective task scheduler.Generate processing element combinations.Function to determine the preference to schedule a task on a set of GridMachines

Figure 2 .
Figure 2. A typical scenario for a proposed scheduling algorithm demonstration.
Greedy scheduler -Minimize TAT and maximize Resource Utilization GCPS Greedy communication price scheduler -Minimize the communication Price (Cost) GEPS Greedy execution price scheduler -Minimize the execution Price (Cost) GNFS Greedy No-Fragmentation scheduler -Minimize TAT and maximize Resource Utilization without fragmenting any task across multiple Grid-Machines R Random scheduler

Figures 4 ,
14, 15, 16 and 17 shows that the greedy execution cost scheduler incurs the least execution cost.The computed values of turnaround time, execution cost, communication cost, and resource utilization using proposed schedulers for random task graphs with 25%, 50%, 75% and 100% dependency with varying number of task nodes and a given number of grid resources are tabulated in Tables 24, 25 and 26 respectively.

Figure 18 .
Figure 18.Scientific task graphs with resource utilization and communication cost.

Figure 19 .
Figure 19.Scientific task graphs with resource utilization and execution cost.

Figure 20 .
Figure 20.Scientific task graphs with resource utilization and TAT.

Figure 21 .
Figure 21.Scientific task graphs with resource utilization and communication cost.

Figure 22 .
Figure 22.Scientific task graphs with TAT and execution cost.

Table 8 .
Schedule sequence of tasks allocated to Grid-machines for objectiveType=G CP .

Table 11 .
Schedule sequence of tasks allocated to grid-machines for objectiveType=G NF .

Table 14 .
Schedule sequence of tasks allocated to Grid-Machines for objectiveType=G EP .

Table 15 .
Key notation definitions.Number of machines present on Grids G 1 , ..., G m Price EG j Price (cost) incurred per second in executing a task on any machine belonging to Grid G j Price C Price(cost) incurred per second in reserving the network link connecting any two different Grids on the Grid Network W GjProcessing Capacity in MIPS (millions of instructions per second) of a single machine belonging to Grid G j p[1, ..., m]

Table 20 .
Simulated/computed TAT for standard task graphs.

Table 30 .
TOPSIS ranking of scheduling algorithms on scientific task graphs.